/*
 * $RCSfile: DbField.java,v $
 * $Revision: 32.37 $
 *
 * Comments:
 *
 * (C) Copyright Biuro-Technika 1996.  All rights reserved.
 * THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF Biuro-Technika
 * The copyright notice above does not evidence any
 * actual or intended publication of such source code.
 *
 * $Author: michal $          $Locker:  $
 * $Date: 2010/06/13 06:35:45 $
 * $Log: DbField.java,v $
 * Revision 32.37  2010/06/13 06:35:45  michal
 * poprawa w metodach equals
 *
 * Revision 32.36  2010/04/22 14:14:37  michal
 * parametryzacja kodu,poprawa pol boolowskich
 *
 * Revision 32.35  2010/02/05 14:01:57  michal
 * dodanie metody sprawdzajacej typ pola timestamp
 *
 * Revision 32.34  2010/02/05 13:40:45  michal
 * dodano obsluge timestampa
 *
 * Revision 32.33  2009/11/17 09:46:08  michal
 * brakowalo break'a przy konstruktorze
 *
 * Revision 32.32  2009/11/02 12:07:50  michal
 * dodano Clob, Blob, Binary
 *
 * Revision 32.31  2009/10/29 12:51:34  michal
 * dodanie Bloba i poprawa Cloba
 *
 * Revision 32.30  2009/10/28 12:40:15  michal
 * dodanie typow Clob oraz Timestamp
 *
 * Revision 32.29  2009/10/12 09:29:50  michal
 * przedefiniowanie metod ustawiajacych
 *
 * Revision 32.28  2009/09/28 08:35:22  michal
 * dodanie mozliwosci wylaczenia pola
 *
 * Revision 32.27  2009/09/23 13:08:42  michal
 * poprawa przy stringach z wartoscia null
 *
 * Revision 32.26  2009/09/23 12:12:06  michal
 * dodanie metody sprawdzajacej czy kolumna jest z parametrem NOT NULL
 *
 * Revision 32.25  2009/09/22 12:57:04  michal
 * poprawa komentarzy
 *
 * Revision 32.24  2009/09/16 13:49:36  michal
 * poprawa w isNumber
 *
 * Revision 32.23  2009/09/16 13:34:36  michal
 * poprawa metod do obslugi pol
 *
 * Revision 32.22  2009/05/27 14:15:37  michal
 * kompatybilnosc z wczesniejszymi wersjami
 *
 * Revision 32.21  2009/05/21 12:54:55  michal
 * dodanie mozliwosci konwersji pol
 *
 * Revision 32.20  2009/05/18 11:51:43  michal
 * dodanie mozliwosci zwrocenia typu pola
 *
 * Revision 32.19  2009/05/18 11:50:10  michal
 * dodanie mozliwosci pobrania dlugosci pola
 *
 * Revision 32.18  2009/05/18 11:48:27  michal
 * modyfikacja definicji pol typu DbTable, dodanie brakujacych typow
 *
 * Revision 32.17  2008/12/16 07:45:10  michal
 * zdefiniowanie metody equals
 *
 * Revision 32.16  2008/11/28 14:29:39  michal
 * dodanie przechowywania informacji o placowkach
 *
 * Revision 32.15  2007/03/05 16:29:02  rudi
 * Optymalizacja importow
 *
 * Revision 32.14  2007/01/16 15:51:32  dominik
 * Zamiana PreparedStatement na DebuggablePreparedStatement - debugowanie zapytania
 *
 * Revision 32.13  2006/03/16 15:49:23  muzzy
 * caps lock
 *
 * Revision 32.12  2005/04/14 13:35:51  limbur
 * Optymalizacja importow...
 *
 * Revision 32.11  2005/04/04 10:21:49  muzzy
 * odziezowka
 *
 * Revision 32.10  2005/01/18 10:15:16  limbur
 * Poprawiono tworzenie widokow.
 *
 * Revision 32.9  2004/12/15 08:43:20  limbur
 * Wersja pod PostgreSQL
 *
 * Revision 32.8  2004/08/20 17:11:31  limbur
 * Zmiany w funkcji dbftString() - dodano IndexOutOfBoundsException
 *
 * Revision 32.7  2004/01/19 17:16:45  limbur
 * Dodano obsluge indeksow
 *
 * Revision 32.6  2004/01/12 15:40:58  muzzy
 * Grupy kontrahentow
 *
 * Revision 32.5  2003/12/11 11:00:05  limbur
 * DbKontrahent
 *
 * Revision 32.4  2003/11/27 10:25:21  limbur
 * Nowa funkcja - dbftString()
 *
 * Revision 32.3  2003/11/26 09:27:46  limbur
 * Blad w DBFT_STATUS
 *
 * Revision 32.2  2003/11/25 17:08:00  limbur
 * Nowe konstruktory, instanceOf, setStatement(), nowe typy
 *
 * Revision 32.1  2003/10/10 16:03:56  limbur
 * Original source code.
 *
 */

package parasoft.centrap.db;

import java.sql.Blob;
import java.sql.Clob;
import java.sql.Date;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.sql.Types;
import java.util.StringTokenizer;

import parasoft.centrap.connection.DebuggablePreparedStatement;
/**
 * Klasa reprezentuj�ca pole tabeli w bazie danych
 *
 */
public class DbField
{
    /**
     * Nazwa pola
     */
    private String sName;
    /** Alias pola. Uzywany do skompilowanych zapyta�
     * @since centrala-2_38
     */
    private String aName;
    /**
     * Typ pola wed�ug centrali
     */
    private final int   _type;
    /**
     * Nazwa typu SQL z parametrami(d�ugo��, NOT NULL,DEFAULT, itd.)
     */
    private String sDataType;
    /**
     * Czy pola jest indeksowane
     */
    private final boolean _indexed;
    /**
     * D�ugo�c pola. U�ywana przy polach z parametrem d�ugo�ci
     */
    private static long length = 0;
    /** Umo�liwia sprawdzanie pola,addRecord,update ... */
    private boolean check = true;

    /**
     * Konstruktor tworz�cy pole klucza g��wnego typu <i>FT_LONG</i> z indeksowaniem
     * @param name nazwa pola
     * @see #DbField(String, String) DbField(nazwa_pola, alias)
     */
    public DbField(final String name)
    {
    	sName = name;
        _type = FT_LONG;
        sDataType = dbftPrimaryKey();
        _indexed = true;
    }

    /**
     * Konstruktor tworz�cy pole klucza g��wnego typu <i>FT_LONG</i> z indeksowaniem.<br>
     * Ustawia alias na kolumnie
     * @param name nazwa pola
     * @param alias nazwa aliasu
     * @see #DbField(String)
     * @see #setAlias(String)
     * @since centrala-2_38
     */
    public DbField(final String name, final String alias)
    {
    	this(name);
    	setAlias(alias);
    }
    
    /**
     * Konstruktor tworz�cy pole typu centralowego <i>type</i> .<br>
     * Ustawia jako klucz g��wny oraz indeksowane je�eli pole jest r�nego typu od podstawowych.<br>
     * @param name nazwa pola
     * @param type typ pola centralowego
     * @see #DbField(String, String, int) DbField(nazwa_pola, alias, typ)
     */
    public DbField(final String name, final int type)
    {
        sName = name;
        _type = type;
        switch(_type) {
            case FT_LONG:
            case FT_INT:
                sDataType = dbftNumber();
                break;
            case FT_DOUBLE:
                sDataType = dbftDouble();
                break;
            case FT_BOOLEAN:
                sDataType = dbftBoolean();
                break;
            case FT_STRING:
                sDataType = dbftString();
                break;
            case FT_DATE:
                sDataType = dbftDate();
                break;
            case FT_TIMESTAMP:
                sDataType = dbftTimeStamp();
                break;
            case FT_CLOB:
                sDataType = dbftClob();
                break;
            case FT_BLOB:
                sDataType = dbftBlob();
                break;
            case FT_BINARY:
                sDataType = dbftBinary();
                break;
            default:
                sDataType = dbftPrimaryKey();
        }
        _indexed = isPrimaryKey();
    }
    /**
     * Konstruktor tworz�cy pole typu centralowego <i>type</i> .<br>
     * Ustawia jako klucz g��wny oraz indeksowane je�eli pole jest r�nego typu od podstawowych.<br>
     * Ustawia alias na kolumnie
     * @param name nazwa pola
     * @param alias nazwa aliasu
     * @param type typ pola centralowego
     * @see #DbField(String, int)
     * @see #setAlias(String)
     * @since centrala-2_38
     */
    public DbField(final String name, final String alias, final int type)
    {
    	this(name,type);
    	setAlias(alias);
    }
    /**
     * Konstruktor tworz�cy pole klucza g��wnego typu <i>FT_LONG</i> z indeksowaniem
     * @param name nazwa pola
     * @param type typ centralowy
     * @param dataType nazwa typu SQL z parametrami(d�ugo��, NOT NULL,DEFAULT, itd.)
     * @see #DbField(String, String, int, String) DbField(nazwa_pola, alias, typ, typSQL)
     */
    public DbField(final String name, final int type, final String dataType)
    {
       sName = name;
        _type = type;
        sDataType = dataType;
        _indexed = isPrimaryKey();
    }
    public DbField(final boolean fcheck,final String name, final int type, final String dataType){
    	this(name, type, dataType);
    	check = fcheck;
    }
    
    /**
     * Konstruktor tworz�cy pole klucza g��wnego typu <i>FT_LONG</i> z indeksowaniem.<br>
     * Ustawia alias na kolumnie
     * @param name nazwa pola
     * @param alias nazwa aliasu
     * @param type typ centralowy
     * @param dataType nazwa typu SQL z parametrami(d�ugo��, NOT NULL,DEFAULT, itd.)
     * @see #DbField(String, int, String) DbField(nazwa_pola, typ, typSQL) 
     * @see #setAlias(String)
     * @since centrala-2_38
     */
    public DbField(final String name, final String alias, final int type, final String dataType)
    {
    	this(name, type, dataType);
    	setAlias(alias);
    }
    /**
     * Konstruktor tworz�cy pole klucza g��wnego typu <i>FT_LONG</i> z indeksowaniem
     * @param name nazwa pola
     * @param type typ centralowy
     * @param dataType nazwa typu SQL z parametrami(d�ugo��, NOT NULL,DEFAULT, itd.)
     * @param indexed czy pole indeksowane
     * @see #DbField(String, String, int, String, boolean) DbField(nazwa_pola, alias, typ, typSQL, indeksowanie)
     */
    public DbField(final String name, final int type, final String dataType, final boolean indexed)
    {
        sName = name;
        _type = type;
        sDataType = dataType;
        _indexed = indexed;
    }
    /**
     * Konstruktor tworz�cy pole klucza g��wnego typu <i>FT_LONG</i> z indeksowaniem.<br>
     * Ustawia alias na kolumnie
     * @param name nazwa pola
     * @param type typ centralowy
     * @param dataType nazwa typu SQL z parametrami(d�ugo��, NOT NULL,DEFAULT, itd.)
     * @param indexed czy indeksowane
     * @see #DbField(String, int, String, boolean) DbField(nazwa_pola, typ, typSQL, indeksowanie)
     * @see #setAlias(String)
     * @since centrala-2_38
     */
    public DbField(final String name,final String alias, final int type, final String dataType, final boolean indexed)
    {
    	this(name, type, dataType, indexed);
    	setAlias(alias);
    }
    /**
     * Zwraca nazw� pola
     * @return nazwa pola
     */
    public String getName()
    {
        return sName;
    }

    /**
     * Zwraca alias pola.<br>
     * @return W przypadku braku zwraca nazw� pola
     */
    public String getAlias(){
    	if((aName==null) || (aName.trim().length()==0)){
    		return sName;
    	}
    	return aName;
    }

    /**
     * Zwraca typ centralowy
     * @return typ
     */
    public int getType()
    {
        return _type;
    }

    /**
     * Zwraca nazw� typu SQL z parametrami je�eli okre�lono(NOT NULL,DEFAULT itd.)
     * @return typSQL
     * @see #getSQLType()
     */
    public String getDataType()
    {
        return sDataType;
    }

    /**
     * Zwraca nazw� typu SQL.<br>
     * Zwracana jest tylko nazwa + ewentualnie parametr d�ugo�ci.<br>
     * Nie s� brane pod uwag� parametry jak NOT NULL,DEFAULT itd.
     * @return nazwaTypuSQL
     * @see DbField#getDataType()
     */
    public String getSQLType()
    {
        final StringTokenizer type = new StringTokenizer(sDataType);
        return type.nextToken();
    }

    /**
     * Czy kolumna jest indekdowana
     * @return isIndexed
     */
    public boolean isIndexed()
    {
        return _indexed;
    }

    /**
     * Zwraca warto�� pola reprezentowanego przez this w zale�no�ci od typu centralowego
     * @param rs ResultSet
     * @return new Object
     * @throws SQLException b��d pobrania warto�ci pola z ResultSet'a
     * @see #getCorrectValue(Object)
     * @see #sqlt2dbft(int)
     */
    public Object getValue(final ResultSet rs) throws SQLException
    {
        switch(_type) {
            case FT_LONG:
                return new Long(rs.getLong(sName));
            case FT_INT:
                return new Integer(rs.getInt(sName));
            case FT_STRING:
                return rs.getString(sName);
            case FT_DOUBLE:
                return new Double(rs.getDouble(sName));
            case FT_BOOLEAN:
                return Boolean.valueOf(rs.getBoolean(sName));
            case FT_DATE:
                return rs.getDate(sName);
            case FT_TIMESTAMP:
                return rs.getTimestamp(sName);
            case FT_CLOB:
                return rs.getObject(sName);
            case FT_BLOB:
                return rs.getBlob(sName);
            default:
                return null;
        }
    }

    /**
     * Zwraca pole poprawnego typu wed�ug typu centralowego.<br>
     * Je�eli jako parametr podamy np.: Long,a w rzeczywisto�ci jest {@link DbTable}, to zwr�ci {@link DbTable} o id r�wnym parametrowi
     * @param inTyp pole wej�ciowe
     * @return poprawiony typ pola lub null w przypadku braku zdefiniowanego typu
     * @see #getValue(ResultSet)
     * @see #sqlt2dbft(int)
     */
    public Object getCorrectValue(final Object inTyp)
    {
        switch(_type) {
            case FT_LONG:
                return new Long(getLong(inTyp));
            case FT_INT:
                return new Integer((int)Double.parseDouble(inTyp.toString()));
            case FT_STRING:
                return inTyp.toString();
            case FT_DOUBLE:
                return new Double(Double.parseDouble(inTyp.toString()));
            case FT_BOOLEAN:
                return Boolean.valueOf(inTyp.toString());
            case FT_DATE:
                return Date.valueOf(inTyp.toString());
            case FT_TIMESTAMP:
                return Timestamp.valueOf(inTyp.toString());
            case FT_CLOB:
                return (inTyp.toString());
            case FT_BLOB:
            case FT_BINARY:
                return new DbBlob(inTyp);
            default:
                return null;
        }
    }

    /**
     * Parsuje tekstow� reprezentacje obiektu na long
     * @param inTyp obiekt wej�ciowy
     * @return long
     * @see Double#parseDouble(String)
     */
    public static long getLong(final Object inTyp){
    	if(inTyp == null){
    		return 0;
    	}
    	return (long)Double.parseDouble(inTyp.toString());
    }

    /**
     * Pobiera long z ResultSet'a dla tego pola
     * @param rs ResultSet
     * @return long
     * @throws SQLException b�ad podczas pobierania danych z ResultSet'a
     * @throws DbException typ centralowy pola jest r�ny od FT_LONG
     * @see #sqlt2dbft(int)
     * @see java.sql.ResultSet#getLong(String)
     */
    public long getLong(final ResultSet rs) throws SQLException, DbException
    {
        if(_type != FT_LONG) {
        }
        return rs.getLong(sName);
    }

    /**
     * Pobiera (long)int z ResultSet'a dla tego pola
     * @param rs ResultSet
     * @return (long)int
     * @throws SQLException b�ad podczas pobierania danych z ResultSet'a
     * @throws DbException typ centralowy pola jest r�ny od FT_INT
     * @see #sqlt2dbft(int)
     * @see java.sql.ResultSet#getInt(String)
     */
    public long getInt(final ResultSet rs) throws SQLException, DbException
    {
        if(_type != FT_INT) {
        }
        return rs.getInt(sName);
    }

    /**
     * Pobiera String z ResultSet'a dla tego pola
     * @param rs ResultSet
     * @return String
     * @throws SQLException b�ad podczas pobierania danych z ResultSet'a
     * @throws DbException typ centralowy pola jest r�ny od FT_STRING
     * @see #sqlt2dbft(int)
     * @see java.sql.ResultSet#getString(String)
     */
    public String getString(final ResultSet rs) throws SQLException, DbException
    {
        if(_type != FT_STRING) {
        }
        return rs.getString(sName);
    }

    /**
     * Pobiera double z ResultSet'a dla tego pola
     * @param rs ResultSet
     * @return double
     * @throws SQLException b�ad podczas pobierania danych z ResultSet'a
     * @throws DbException typ centralowy pola jest r�ny od FT_DOUBLE
     * @see #sqlt2dbft(int)
     * @see java.sql.ResultSet#getDouble(String)
     */
    public double getDouble(final ResultSet rs) throws SQLException, DbException
    {
        if(_type != FT_DOUBLE) {
        }
        return rs.getDouble(sName);
    }

    /**
     * Pobiera boolean z ResultSet'a dla tego pola
     * @param rs ResultSet
     * @return boolean
     * @throws SQLException b�ad podczas pobierania danych z ResultSet'a
     * @throws DbException typ centralowy pola jest r�ny od FT_BOOLEAN
     * @see #sqlt2dbft(int)
     * @see java.sql.ResultSet#getBoolean(String)
     */
    public boolean getBoolean(final ResultSet rs) throws SQLException, DbException
    {
        if(_type != FT_BOOLEAN) {
        }
        return rs.getBoolean(sName);
    }

    /**
     * Pobiera java.sql.Date z ResultSet'a dla tego pola
     * @param rs ResultSet
     * @return java.sql.Date
     * @throws SQLException b�ad podczas pobierania danych z ResultSet'a
     * @throws DbException typ centralowy pola jest r�ny od FT_DATE
     * @see #sqlt2dbft(int)
     * @see java.sql.ResultSet#getDate(String)
     * @see java.sql.Date
     */
    public Date getDate(final ResultSet rs) throws SQLException, DbException
    {
        if(_type != FT_DATE) {
        }
        return rs.getDate(sName);
    }

    /**
     * Sprawdza czy to pola jest typu obiektu podanego jako parametr.<br>
     * Sprawdzanie jest uzale�nione od typu centralowego tego pola.<br>
     * Dost�pne typu obiekt�w to:
     * <ol>
     * <li> Long 
     * <li> Integer
     * <li> String
     * <li> Double
     * <li> Boolean
     * <li> Date
     * <li> {@link DbTable}
     *  </ol>
     * @param object obiekt sprawdzaj�cy
     * @return boolean
     * @see #sqlt2dbft(int)
     */
    public boolean instanceOf(final Object object)
    {
        switch(_type) {
            case FT_LONG:
                return object instanceof Long;
            case FT_INT:
                return object instanceof Integer;
            case FT_STRING:
            case FT_CLOB:
                return object instanceof String;
            case FT_BLOB:
            	return object instanceof Blob;
            case FT_BINARY:
            	return ((object instanceof byte[])||(object instanceof Blob));
            case FT_DOUBLE:
                return object instanceof Double;
            case FT_BOOLEAN:
                return object instanceof Boolean;
            case FT_DATE:
                return object instanceof Date;    
            case FT_TIMESTAMP:
                    return object instanceof Timestamp;
            default:
                return false;
        }
    }

    /**
     * Ustawia warto��(value) pola o numerze(index) w zapytaniu(stmt) wed�ug tego pola(this).<br>
     * Sprawdzanie jest uzale�nione od typu centralowego tego pola.<br>
     * Dost�pne typu warto�ci to:
     * <ol>
     * <li> Long 
     * <li> Integer
     * <li> String
     * <li> Double
     * <li> Boolean
     * <li> Date
     * <li> {@link DbTable} -> {@link DbTable#getKeyLongValue()}
     *  </ol>
     * @param stmt DebuggablePreparedStatement
     * @param index numer parametru w Statement
     * @param value ustawiana warto��
     * @throws SQLException b��d przy ustawianiu parametru
     * @throws DbException nie rozpoznany typ pola centralowego
     * @see #sqlt2dbft(int)
     */
    public DbField setStatement(final DebuggablePreparedStatement stmt, final int index, final Object value)
        throws SQLException, DbException
    {
        switch(_type) {
            case FT_LONG:
                	stmt.setLong(index, ((Long)value).longValue());
                break;
            case FT_INT:
            		stmt.setInt(index, ((Integer)value).intValue());
                break;
            case FT_STRING:
            case FT_CLOB:
                    stmt.setString(index, ( (String) value));
                break;
            case FT_BINARY:
	            	stmt.setBytes(index, ((DbBlob)value).getBytes());
            	break;
            case FT_BLOB:
	            	stmt.setBlob(index, ((DbBlob)value));
            	break;
            case FT_DOUBLE:
            		stmt.setDouble(index, ((Double)value).doubleValue());
                break;
            case FT_BOOLEAN:
            		stmt.setBoolean(index, ((Boolean)value).booleanValue());
                break;
            case FT_DATE:
                stmt.setDate(index, ((Date)value));
                break;
            case FT_TIMESTAMP:
                stmt.setTimestamp(index, ((Timestamp)value));
                break;
            case FT_TANKIETA:
            case FT_TBAZY_RACH:
            case FT_TBRANZA:
            case FT_TCECHA:
            case FT_TCENNIK:
            case FT_TCENTRALA:
            case FT_TCHANGELOG:
            case FT_TCONFIG:
            case FT_TDBPARAMS:
            case FT_TDATABASE:
            case FT_TDOKTMP:
            case FT_TDZIAL:
            case FT_TGROUP_ALIASES:
            case FT_TGRUPA:
            case FT_TPGRUPA:
            case FT_TGRUPA_KARTA:
            case FT_TGRUPA_KNT:
            case FT_TJEDNOSTKA:
            case FT_TKLIENT:
            case FT_TKLIENT_KARTA:
            case FT_TKONTRAHENT:
            case FT_TKONTRAKT:
            case FT_TMATRIX:
            case FT_TMAGAZYN:
            case FT_TMENU:
            case FT_TMULTIKOD:
            case FT_TNAGLOWEK_RACH:
            case FT_TODPOWIEDZ:
            case FT_TODPOWIEDZ_STR:
            case FT_TODZIEZ:
            case FT_TPOZ_ANKIET:
            case FT_TPOZ_KLNT:
            case FT_TPOZ_RACH:
            case FT_TPOZYCJA_RACH:
            case FT_TPOZYCJA_ZAM:
            case FT_TPRACOWNIK:
            case FT_TPRIVILEGE:
            case FT_TRACHUNEK:
            case FT_TRAPORT:
            case FT_TSLOWNIK:
            case FT_TTOWAR:
            case FT_TTOWAR_REC:
            case FT_TTOWAR_PLAC:
            case FT_TTOWAR_USER:
            case FT_TUSER:
            case FT_TUFIELDS:
            case FT_TZAMCENTR:

            default:
        }
        return this;
    }

    /**
     * Zwraca nazw� typu SQL reprezentuj�c� ciag znak�w o d�ugo�ci 128
     * @return varchar(128)
     * @see #dbftString(int)
     */
    public static String dbftString()
    {
        length = 128;
		return "(128)";
    }

    /**
     * Zwraca nazw� typu SQL reprezentuj�c� kolumn� typu CLOB
     * @return clob
     */
    public static String dbftClob()
    {
		return "" + (Types.CLOB);
    }
    
    /**
     * Zwraca nazw� typu SQL reprezentuj�c� kolumn� typu BLOB
     * @return blob
     */
    public static String dbftBlob()
    {
		return "" + (Types.BLOB);
    }
    
    /**
     * Zwraca nazw� typu SQL reprezentuj�c� kolumn� typu BINARY
     * @return binary
     */
    public static String dbftBinary()
    {
		return "" + (Types.BINARY);
    }

    /**
     * Zwraca nazw� typu SQL reprezentuj�c� ciag znak�w o d�ugo�ci podanej w parametrze len
     * @param len d�ugo�� pola
     * @return varchar(len)
     */
    public static String dbftString(int len)
    {
        if(len <= 0) {
            throw new IndexOutOfBoundsException();
        }
        if(len > 512) {
            len = 512;
        }
        length = len;
		return "" + (Types.VARCHAR) +
            "(" + len + ")";
    }

    /**
     * Zwraca nazw� typu SQL reprezentuj�c� kolumn� typu BIGINT z klauzul� PRIMARY KEY
     * @return bigint PRIMERY KEY
     */
    public static String dbftPrimaryKey()
    {
		return "" + (Types.BIGINT) + PRIMARY_KEY;
    }

    /**
     * Zwraca nazw� typu SQL reprezentuj�c� kolumn� STATUS w tabeli
     * @return smallint DEFAULT 0 NOT NULL
     */
    public static String dbftStatus()
    {
		return "" + (Types.SMALLINT) +
            " DEFAULT 0 NOT NULL";
    }

    /**
     * Zwraca nazw� typu SQL reprezentuj�c� kolumn� typu BIGINT
     * @return bigint
     */
    public static String dbftBigint()
    {
		return "" + (Types.BIGINT);
    }

    /**
     * Zwraca nazw� typu SQL reprezentuj�c� kolumn� typu INTEGER
     * @return INTEGER
     */
    public static String dbftInteger()
    {
		return "" + (Types.INTEGER);
    }

    /**
     * Zwraca nazw� typu SQL reprezentuj�c� kolumn� typu SMALLINT
     * @return SMALLINT
     */
    public static String dbftSmallint()
    {
		return "" + (Types.SMALLINT);
    }

    /**
     * Zwraca nazw� typu SQL reprezentuj�c� kolumn� typu BIGINT
     * @return BIGINT
     */
    public static String dbftNumber()
    {
		return "" + (Types.BIGINT);
    }

    /**
     * Zwraca nazw� typu SQL reprezentuj�c� kolumn� typu NUMERIC o precyzji podanej jako parametr
     * @param precision precyzja
     * @return NUMBER(precision)
     */
    public static String dbftNumber(final int precision)
    {
        length = precision;
		return "" + (Types.NUMERIC) +
            "(" + precision + ")";
    }

    /**
     * Zwraca nazw� typu SQL reprezentuj�c� kolumn� typu NUMERIC o podanej precyzji oraz skali
     * @param precision precyzja
     * @param scale skala
     * @return NUMBER(precision, scale)
     */
    public static String dbftNumber(final int precision, final int scale)
    {
    	length = precision;
		return "" + (Types.NUMERIC) +
            "(" + precision + "," + scale + ")";
    }

    /**
     * Zwraca nazw� typu SQL reprezentuj�c� kolumn� typu FLOAT
     * @return FLOAT
     */
    public static String dbftFloat()
    {
		return "" + (Types.FLOAT);
    }

    /**
     * Zwraca nazw� typu SQL reprezentuj�c� kolumn� typu DOUBLE
     * @return DOUBLE
     */
    public static String dbftDouble()
    {
		return "" + (Types.DOUBLE);
    }

    /**
     * Zwraca nazw� typu SQL reprezentuj�c� kolumn� typu DATE
     * @return DATE
     */
    public static String dbftDate()
    {
		return "" + (Types.DATE);
    }

    /**
     * Zwraca nazw� typu SQL reprezentuj�c� kolumn� typu TIMESTAMP
     * @return TIMESTAMP
     */
    public static String dbftTimeStamp()
    {
		return "" + (Types.TIMESTAMP);
    }

    /**
     * Zwraca nazw� typu SQL reprezentuj�c� kolumn� typu BOOLEAN
     * @return BOOLEAN
     */
    public static String dbftBoolean()
    {
		return "" + (Types.BOOLEAN);
    }

    /**
     * Zwraca nazw� typu SQL reprezentuj�c� kolumn� typu BOOLEAN z podan� domy�ln� warto�ci�
     * @param def warto�� domy�lna
     * @return BOOLEAN DEFAULT def
     */
    public static String dbftBoolean(final boolean def)
    {
        return dbftBoolean() + " DEFAULT " + Boolean.valueOf(def);
    }

    /**
     * Zwraca klauzuj� DEFAULT z podan� domy�ln� warto�ci�
     * @param o domy�lna warto�� liczbowa
     * @return DEFAULT o
     */
    public static String dbfd(final int o){
    	return " DEFAULT " + String.valueOf(o);
    }

    /**
     * Zwraca klauzuj� DEFAULT z podan� domy�ln� warto�ci�.<br>
     * W przypadku gdy parametr jest warto�ci� null zwraca DEFAULT NULL
     * @param o domy�lna warto��
     * @return DEFAULT o
     */
    public static String dbfd(final Object o){
    	return " DEFAULT " + String.valueOf(o);
    }

    /**
     * Sprawdza czy pole jest typu Number :(Long, Integer, Double).<br>
     * Z uwagi, �e pole typu {@link DbTable} jest konwertowane na warto�� klucza g��wnego tego pola(Long),
     * to pole typu {@link DbTable} r�wnie� jest typu Number.<br>
     * Sprawdzanie jest uzale�nione od typu centralowego tego pola.
     * @return boolean
     * @see #dbfc()
     * @see #isDbTable()
     * @see #sqlt2dbft(int)
     */
    public boolean isNumber(){
    	return dbfc().getSuperclass().equals(Number.class) || isDbTable();
    }
    
    /**
     * Sprawdza czy pole jest typu Long.<br>
     * Sprawdzanie jest uzale�nione od typu centralowego tego pola.<br>
     * @return boolean
     * @see #instanceOf(Object)
     * @see #sqlt2dbft(int)
     */
    public boolean isLong(){
    	return instanceOf(LONG);
    }

    /**
     * Sprawdza czy pole jest typu Integer.<br>
     * Sprawdzanie jest uzale�nione od typu centralowego tego pola.
     * @return boolean
     * @see #instanceOf(Object)
     * @see #sqlt2dbft(int)
     */
    public boolean isInteger(){
    	return instanceOf(INT);
    }

    /**
     * Sprawdza czy pole jest typu String.<br>
     * Sprawdzanie jest uzale�nione od typu centralowego tego pola.
     * @return boolean
     * @see #instanceOf(Object)
     * @see #sqlt2dbft(int)
     */
    public boolean isString(){
    	return instanceOf("");
    }

    /**
     * Sprawdza czy pole jest typu Double).<br>
     * Sprawdzanie jest uzale�nione od typu centralowego tego pola.
     * @return boolean
     * @see #instanceOf(Object)
     * @see #sqlt2dbft(int)
     */
    public boolean isDouble(){
    	return instanceOf(DOUBLE);
    }

    /**
     * Sprawdza czy pole jest typu Boolean).<br>
     * Sprawdzanie jest uzale�nione od typu centralowego tego pola.
     * @return boolean
     * @see #instanceOf(Object)
     * @see #sqlt2dbft(int)
     */
    public boolean isBoolean(){
    	return instanceOf(BOOL);
    }

    /**
     * Sprawdza czy pole jest typu Date.<br>
     * Sprawdzanie jest uzale�nione od typu centralowego tego pola.
     * @return boolean
     * @see #instanceOf(Object)
     * @see #sqlt2dbft(int)
     */
    public boolean isDate(){
    	return instanceOf(DATE);
    }

    /**
     * Sprawdza czy pole jest typu Timestamp.<br>
     * Sprawdzanie jest uzale�nione od typu centralowego tego pola.
     * @return boolean
     * @see #instanceOf(Object)
     * @see #sqlt2dbft(int)
     */
    public boolean isTimestamp(){
    	return instanceOf(TIMESTAMP);
    }
    /**
     * Sprawdza czy pole jest typu {@link DbTable}.<br>
     * Sprawdzanie jest uzale�nione od typu centralowego tego pola.
     * @return boolean
     * @see #instanceOf(Object)
     * @see #isNumber()
     * @see #sqlt2dbft(int)
     */
    public boolean isDbTable(){
		return dbfc().getSuperclass().equals(Class.class);
    }


    /**
     * Zwraca obiekt Class reprezentuj�cy typ tego pola.<br> 
     * Sprawdzanie jest uzale�nione od typu centralowego tego pola.
     * @return Class
     * @see #sqlt2dbft(int)
     */
    public Class<?> dbfc(){
	   switch(_type) {
	        case FT_LONG:
	            return Long.class;
	        case FT_INT:
	            return Integer.class;
	        case FT_STRING:
	            return String.class;
	        case FT_DOUBLE:
	            return Double.class;
	        case FT_BOOLEAN:
	            return Boolean.class;
	        case FT_DATE:
	            return Date.class;
	        case FT_CLOB:
	            return Clob.class;
   	        case FT_BLOB:
   	        	return Blob.class;
	        case FT_BINARY:
	            return byte[].class;
	        default:
	            return Long.class;
	    }
    }


    /**
     * Zwraca obiekt Class.toString() reprezentuj�cy typ rzeczywisty tego pola.(Long, {@link DbTable}, itd.)<br> 
     * Sprawdzanie jest uzale�nione od typu centralowego tego pola.
     * @return reprezentacj� tekstow� klasy
     * @see #sqlt2dbft(int)
     */
    public String dbft()
    {
    	return String.valueOf(dbfc());
    }

    /**
     * Konwertuje typ sql java.sql.Types na typ centralowy
     * @param type
     * @return typ zrozumia�y dla pola {@link DbField}
     * @see #dbft()
     * @see #getSQLType()
     * @see DbField#instanceOf(Object)
     */
    public static long sqlt2dbft(final int type)
    {
        switch(type) {
            case Types.BIGINT:
            case Types.INTEGER:
            case Types.DECIMAL:
            case Types.NUMERIC:
            	return FT_LONG;
            case Types.SMALLINT:
            case Types.TINYINT:
                return FT_INT;
            case Types.VARCHAR:
            case Types.CHAR:
            case Types.LONGVARCHAR:
                return FT_STRING;
            case Types.DOUBLE:
            case Types.FLOAT:
            case Types.REAL:
                return FT_DOUBLE;
            case Types.BOOLEAN:
            case Types.BIT:
                return FT_BOOLEAN;
            case Types.DATE:
                return FT_DATE;
            case Types.TIMESTAMP:
                return FT_TIMESTAMP;
            case Types.CLOB:
                return FT_CLOB;
            case Types.BINARY:
                return FT_BINARY;
            case Types.BLOB:	
                return FT_BLOB;
            default:
                return FT_LONG;
        }
    }

    /**
     * Zwraca informacje o tym czy pole jest kluczem g��wnym w tabeli
     * @return czy k�ucz g��wny
     */
    public boolean isPrimaryKey()
    {
        return !(sDataType.toUpperCase().indexOf(PRIMARY_KEY) < 0);
    }
    
    /**
     * Zwraca informacje o tym czy pole jest NOT NULL
     * @return czy NOT NULL
     */
    public boolean isNotNull(){
    	return !(sDataType.toUpperCase().indexOf(NOT_NULL) < 0);
    }

    /* (non-Javadoc)
     * @see java.lang.Object#equals(java.lang.Object)
     */
    @Override
	public boolean equals(final Object obj) {
    	if(obj instanceof DbField){
    		if(((DbField)obj).getName().equals( this.sName)){
        		return true;
        	}
    	}else
   		if(obj instanceof String){
   			return this.sName.equals(obj);
    	}
    	return false;
    }
    public boolean equalsIgnoreCase(final Object obj) {
    	if(obj instanceof DbField){
    		if(((DbField)obj).getName().equalsIgnoreCase( this.sName)){
        		return true;
        	}
    	}else
   		if(obj instanceof String){
   			return this.sName.equalsIgnoreCase((String)obj);
    	}
    	return false;
    }

    /* (non-Javadoc)
     * @see java.lang.Object#hashCode()
     */
    @Override
	public int hashCode() {
    	return getName().hashCode();
    }

    /**
     * Zwraca d�ugo�� pola
     * @return d�ugo�c pola
     */
    public long getLen(){
    	return length;
    }
    
    /**
     * Czy pole jest sprawdzane
     * @return boolean
     */
    public boolean check(){
    	return check;
    }
    
    public DbField setCheck(final boolean nCheck){
    	check = nCheck;return this;
    }

    /**
     * Ustawia nazwe na kolumnie
     * @param name
     */
    public DbField setName(final String name){
    	sName = name;return this;
    }
    
    /**
     * Ustawia alias na kolumnie
     * @param alias
     */
    public DbField setAlias(final String alias){
    	aName = alias;return this;
    }
    
    /* (non-Javadoc)
     * @see java.lang.Object#toString()
     */
    @Override
	public String toString() {
    	return getName()+" "+getDataType()+" "+getSQLType() + dbft();
    }

    /** Long */
    public final static int FT_LONG         	= 0x0001;
    /** Integer */
    public final static int FT_INT          	= 0x0002;
    /** Double */
    public final static int FT_DOUBLE       	= 0x0003;
    /** Boolean */
    public final static int FT_BOOLEAN      	= 0x0004;
    /** String */
    public final static int FT_STRING       	= 0x0005;
    /** Date */
    public final static int FT_DATE         	= 0x0006;
    /** Timestamp */
    public final static int FT_TIMESTAMP    	= 0x0007;
    /** Clob */
    public final static int FT_CLOB         	= 0x0008;
    /** Blob */
    public final static int FT_BLOB         	= 0x0009;
    /** Binary */
    public final static int FT_BINARY         	= 0x0099;
    /** {@link DbBranza} == Long */
    public final static int FT_TBRANZA      = 0x0103;
    /** {@link DbDzial} == Long */
    public final static int FT_TDZIAL       = 0x0104;
    /** {@link DbGrupa} == Long */
    public final static int FT_TGRUPA       = 0x0105;
    /** {@link DbPodgrupa} == Long */
    public final static int FT_TPGRUPA       = 0x01051;
    /** {@link DbTowar} == Long */
    public final static int FT_TTOWAR       = 0x0106;
    /** {@link DbJednostka} == Long */
    public final static int FT_TJEDNOSTKA   = 0x0108;
    /** {@link DbGrupaKnt} == Long */
    public final static int FT_TGRUPA_KNT   = 0x0109;
    /** {@link DbSlownik} == Long */
    public final static int FT_TSLOWNIK     = 0x011F;
    /** {@link DbUsrFields} == Long */
    public final static int FT_TUFIELDS     = 0x0120;
    /** {@link DbKontrahent} == Long */
    public final static int FT_TKONTRAHENT  = 0x0121;
    /** {@link DbCecha} == Long */
    public final static int FT_TCECHA       = 0x0122;
    /** {@link DbOdziez} == Long */
    public final static int FT_TODZIEZ      = 0x0123;
    /** deprecated {@link DbDatabases} == Long */
    public final static int FT_DATABASE      = 0x0124;
    /** {@link DbAnkiety} == Long */
    public final static int FT_TANKIETA     	= 0x0100;
    /** {@link DbAnyTable} == Long */
    public final static int FT_TANYTABLE    	= 0x0101;
    /** {@link DbBazyRach} == Long */
    public final static int FT_TBAZY_RACH    	= 0x0102;
    /** {@link DbCenniki} == Long */
    public final static int FT_TCENNIK    		= 0x01059;
    /** {@link DbCentrala} == Long */
    public final static int FT_TCENTRALA   		= 0x01069;
    /** {@link DbChangeLog} == Long */
    public final static int FT_TCHANGELOG   	= 0x0107;
    /** {@link DbConfig} == Long */
    public final static int FT_TCONFIG    		= 0x01089;
    /** {@link DbDatabaseParameters} == Long */
    public final static int FT_TDBPARAMS   		= 0x01099;
    /** {@link DbDokTmp} == Long */
    public final static int FT_TDOKTMP    		= 0x0111;
    public final static int FT_TEXCEPTION  		= 0x0113;
    public final static int FT_TFIELD    		= 0x0114;
    /** {@link DbGroupAliases} == Long */
    public final static int FT_TGROUP_ALIASES	= 0x0115;
    /** {@link DbGrupaKarta} == Long */
    public final static int FT_TGRUPA_KARTA 		= 0x0117;
    /** {@link DbKlienci} == Long */
    public final static int FT_TKLIENT    		= 0x01209;
    /** {@link DbKlientKarta} == Long */
    public final static int FT_TKLIENT_KARTA		= 0x01219;
    /** {@link DbKontrakty} == Long */
    public final static int FT_TKONTRAKT  		= 0x01239;
    /** {@link DbDatabases} == Long */
    public final static int FT_TDATABASE  		= 0x0124;
    /** {@link DbMacierzRabatowa} == Long */
    public final static int FT_TMATRIX    		= 0x01249;
    /** {@link DbMagazyn} == Long */
    public final static int FT_TMAGAZYN    		= 0x0125;
    /** {@link DbMenu} == Long */
    public final static int FT_TMENU    		= 0x0126;
    /** {@link DbMultikod} == Long */
    public final static int FT_TMULTIKOD   		= 0x0127;
    /** {@link DbNaglowkiRach} == Long */
    public final static int FT_TNAGLOWEK_RACH	= 0x0128;
    /** {@link DbOdpowiedzi} == Long */
    public final static int FT_TODPOWIEDZ 		= 0x0129;
    /** {@link DbOdpowiedziStr} == Long */
    public final static int FT_TODPOWIEDZ_STR	= 0x0130;
    /** {@link DbPozAnkiet} == Long */
    public final static int FT_TPOZ_ANKIET  		= 0x0132;
    /** {@link DbPozKlnt} == Long */
    public final static int FT_TPOZ_KLNT    		= 0x0133;
    /** {@link DbPozRach} == Long */
    public final static int FT_TPOZ_RACH    		= 0x0134;
    /** {@link DbPozycjeRach} == Long */
    public final static int FT_TPOZYCJA_RACH		= 0x0135;
    /** {@link DbPozycjeZam} == Long */
    public final static int FT_TPOZYCJA_ZAM 		= 0x0136;
    /** {@link DbPracownicy} == Long */
    public final static int FT_TPRACOWNIK 		= 0x0137;
    /** {@link DbPrivilege} == Long */
    public final static int FT_TPRIVILEGE 		= 0x0138;
    /** {@link DbRachunek} == Long */
    public final static int FT_TRACHUNEK 		= 0x0139;
    /** {@link DbRaporty} == Long */
    public final static int FT_TRAPORT	 		= 0x0140;
    /** {@link DbTable} == Long */
    public final static int FT_TTABLE 			= 0x0142;
    /** {@link DbTowarRec} ?= Long */
    public final static int FT_TTOWAR_REC 		= 0x0144;
    /** {@link DbTowaryPlac} == Long */
    public final static int FT_TTOWAR_PLAC 		= 0x0145;
    /** {@link DbTowaryUzytkownika} == Long */
    public final static int FT_TTOWAR_USER 		= 0x0146;
    /** {@link DbUsers} == Long */
    public final static int FT_TUSER 	      	= 0x0147;
    /** {@link DbZamCentr} == Long */
    public final static int FT_TZAMCENTR	   	= 0x0149;
    /** {@link DbZamowienia} == Long */
    public final static int FT_TZAMOWIENIE     	= 0x0150;
    public final static String PRIMARY_KEY = " PRIMARY KEY";
    public final static String NOT_NULL    = " NOT NULL";
    public final static String UNIQUE      = " UNIQUE";
    
    private final static Long LONG = Long.valueOf(0);
    private final static Double DOUBLE = Double.valueOf(0);
    private final static Float FLOAT = Float.valueOf(0);
    private final static Integer INT = Integer.valueOf(0);
    private final static Boolean BOOL = Boolean.TRUE;
    private final static Date DATE = new Date(0);
    private final static Timestamp TIMESTAMP  = new Timestamp(0);
}
